﻿#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
using namespace std;
//
//int main()
//{
//	vector<int> v{ 1,2,3,4,5,6,7 };
//	auto it = v.begin() + 6;
//	reverse(v.begin(), it);
//
//	cout << *it << endl;
//	for (auto e : v)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//}

//int main()
//{
//	int ar[] = { 0,1, 2, 3, 4,  5, 6, 7, 8, 9 };
//	int n = sizeof(ar) / sizeof(int);
//	list<int> mylist(ar, ar + n);
//	list<int>::iterator pos = find(mylist.begin(), mylist.end(), 5);
//	reverse(mylist.begin(), pos);
//
//	cout << *pos << endl;
//	list<int>::const_iterator crit = mylist.cbegin();
//	while (crit != mylist.cend())
//	{
//		cout << *crit << " ";
//		++crit;
//	}
//	cout << endl;
//
//	cout << *pos << endl;
//	reverse(pos, mylist.end());
//	list<int>::const_iterator crit1 = mylist.cbegin();
//	while (crit1 != mylist.cend())
//	{
//		cout << *crit1 << " ";
//		++crit1;
//	}
//	cout << endl;
//}

//void test1()
//{
//	list<int> lt;
//	lt.push_back(1);
//	lt.push_back(2);
//	lt.push_back(3);
//	lt.push_back(4);
//	lt.push_back(5);
//
//	list<int>::iterator it = lt.begin();
//	while (it != lt.end())
//	{
//		cout << *it << " ";
//		it++;
//	}
//	cout << endl;
//	list<int> lt1(lt);
//	list<int>::iterator it1 = lt1.begin();
//	while (it1 != lt1.end())
//	{
//		cout << *it1 << " ";
//		it1++;
//	}
//	cout << endl;
//
//	list<int> lt2(10, 1);
//	list<int>::iterator it2 = lt2.begin();
//	while (it2 != lt2.end())
//	{
//		cout << *it2 << " ";
//		it2++;
//	}
//	cout << endl;
//
//	list<int> lt3{ 1,2,3,4,5,6,7,8,9 };
//	list<int>::iterator it3 = lt3.begin();
//	while (it3 != lt3.end())
//	{
//		cout << *it3 << " ";
//		it3++;
//	}
//	cout << endl;
//	cout << endl;
//
//
//	
//	list<int> lt4(lt3.begin(), --lt3.end());
//	//list的迭代器不支持 - + -= += 只支持++，--
//	list<int>::iterator it4 = lt4.begin();
//	while (it4 != lt4.end())
//	{
//		cout << *it4 << " ";
//		it4++;
//	}
//	cout << endl;
//
//	cout << lt4.size() << endl;
//	cout << lt4.front() << endl;
//	cout << *(lt4.begin()) << endl;
//	cout << endl;
//
//	cout << lt4.back() << endl;
//	cout << *(--lt4.end()) << endl;
//}
//
//
//void test2()
//{
//	list<int> lt1{ 1,2,3,4,5,6,7,8,9 };
//	list<int> lt2{ 10,20,30,40,50,60,70,80,90 };
//
//	lt1.insert(++(++lt1.begin()), 100);
//
//	lt1.insert(++(++lt1.begin()), 3,111);
//
//	lt1.insert(++(++lt1.begin()), ++lt2.begin(),----lt2.end());
//
//
//	list<int>::iterator it = lt1.begin();
//	while (it != lt1.end())
//	{
//		cout << *it << " ";
//		it++;
//	}
//	cout << endl;
//}
//
//void test3()
//{
//	list<int> lt1{ 4,6,2,8,5,4,6,0,1,4,4,4,4,55,34,};
//	lt1.reverse();//list中的reverse
//	reverse(lt1.begin(), lt1.end());//<algorithm>中的reverse
//	//使用<algorithm>中的还是list中的reverse函数都可以
//	list<int>::iterator it = lt1.begin();
//
//
//	//<algorithm>和list中也都各有一个sort()
//	//但是对于list来说，只能使用list库中的sort
//	lt1.sort();
//	//sort(lt1.begin(), lt1.end());  不可以这么用
//
//	//lt1.unique();
//
//	lt1.remove(4);
//
//	it = lt1.begin();
//	while (it != lt1.end())
//	{
//		cout << *it << " ";
//		it++;
//	}
//	cout << endl;
//
//}
//
//
//void test4()
//{
//	int myints[] = { 4,4,4,4,417,89,7,14 };
//	std::list<int> mylist(myints, myints + 8);
//
//	mylist.remove(4);
//
//	std::cout << "mylist contains:";
//	for (std::list<int>::iterator it = mylist.begin(); it != mylist.end(); ++it)
//		std::cout << ' ' << *it;
//	std::cout << '\n';
//
//}
//
//void test5()
//{
//	list<int> lt1{1,2,3,4,5,6,7,8,9};
//	list<int> lt2{ 0,0,0,0,0 };
//	lt2.splice(++lt2.begin(), lt1,++++++++lt1.begin());
//
//	list<int>::iterator it = lt2.begin();
//	while (it != lt2.end())
//	{
//		cout << *it << " ";
//		it++;
//	}
//	cout << endl;
//}

void test1()
{
	list<int> lt1;//无参构造

	list<int> lt2(10, 1);//1,1,1,1,1,1,1,1,1,1

	list<int> lt3(lt2);//拷贝构造

	list<int> lt4(lt2.begin(), lt2.end());

	list<int> lt5;
	lt5 = lt4;//赋值重载
}


void test2()
{
	list<int> lt{ 1,2,3,4,5,6 };
	list<int>::iterator it = lt.begin();
	for (size_t i = 0; i < 5; i++)
	{
		++it;
	}
}

void test3()
{
	list<int> lt{ 1,2,3,4,5,6 };
	lt.push_back(10);
	lt.push_front(0);
	lt.pop_back();
	lt.pop_front();
}

void test4()
{
	list<int> lt{ 1,2,3,4,5,6 };
	lt.reverse();
	reverse(lt.begin(), lt.end());
}

void test5()
{
	list<int> lt{ 5,7,3,9,1,0,4,7,8,9,4, };
	vector<int> v;

	//将数据从list拷贝到vector
	for (auto e : lt)
	{
		v.push_back(e);
	}

	//在vector中排序
	reverse(v.begin(), v.end());

	//再把数据从vector拷贝到list中
	for (auto e : v)
	{
		lt.push_back(e);
	}

}

void test6()
{
	list<int> lt{1,2,3,4,5,6,6,7,8};

	//移除元素6
	lt.remove(6);//1,2,3,4,5,7,8
}


void test7()
{
	list<int> lt1{ 1,2,3,4,5,6,7 };
	list<int> lt2{ 0,0 };

	lt2.splice(++lt2.begin(), lt1);

	for (auto e : lt1)
	{
		cout << e << " ";
	}//lt1中的元素转移空了
	cout << endl;

	for (auto e : lt2)
	{
		cout << e << " ";
	}//0 1 2 3 4 5 6 7 0
	cout << endl;


	list<int> lt3{ 1,2,3,4,5,6,7 };
	list<int> lt4{ 0,0 };

	lt4.splice(++lt4.begin(), lt3, ++lt3.begin());
	for (auto e : lt3)
	{
		cout << e << " ";
	}//1 3 4 5 6 7
	cout << endl;

	for (auto e : lt4)
	{
		cout << e << " ";
	}//0 2 0
	cout << endl;


	list<int> lt5{ 1,2,3,4,5,6,7 };
	list<int> lt6{ 0,0 };

	lt6.splice(++lt6.begin(), lt5,++++lt5.begin(), --lt5.end());
	for (auto e : lt5)
	{
		cout << e << " ";
	}//1 2 7
	cout << endl;

	for (auto e : lt6)
	{
		cout << e << " ";
	}//0 3 4 5 6 0
	cout << endl;
}

int main()
{
	test7();
	return 0;
}








//namespace my_vector
//{
//	template<class T>
//	class vector
//	{
//		typedef T* iterator;
//		typedef const T* const_iterator;
//
//	public:
//		size_t size()const
//		{
//			return _finish - _start;
//		}
//
//		size_t capacity()const
//		{
//			return _end_of_storage - _start;
//		}
//
//		void reserve(size_t n)
//		{
//			if (n > capacity())
//			{
//				T* tmp = new T[n];
//				int oldlen = _finish - _start;
//				if (_start)
//				{
//					memcpy(tmp, _start, sizeof(T) * size());
//					delete _start;
//				}
//				_start = tmp;
//				_finiah = _start + oldlen;
//				_end_of_storage = _start + n;
//			}
//		}
//
//
//		void resize(size_t n, const T& val = T())
//		{
//			if (n < size())
//			{
//				_finish = _start + n;
//			}
//			else
//			{
//				reserve(n);
//				
//				while (_finish!=_start+n)
//				{
//					*_finish = val;
//					++_finish;
//				}
//			}
//		}
//
//		void insert(iterator pos, const T& t)
//		{
//			assert(pos >= begin() && pos < end());
//			if (size() == capacity())
//			{
//				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
//				reserve(newcapacity);
//			}
//
//			iterator end = _finish-1;
//			for (end >= pos)
//			{
//				*(end + 1) = *end;
//				end--;
//			}
//			*pos = t;
//			_finish++;
//		}
//
//		iterator erase(iterator pos)
//		{
//
//		}
//	private:
//		iterator _start;
//		iterator _finish;
//		iterator _end_of_storage;
//	};
//}